home *** CD-ROM | disk | FTP | other *** search
/ Aminet 16 / Aminet 16 (1996)(GTI - Schatztruhe)[!][Dec 1996].iso / Aminet / comm / term / term_source.lha / Extras / Source / term-source.lha / TranslationPanel.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  16KB  |  773 lines
  1. /*
  2. **    TranslationPanel.c
  3. **
  4. **    Character code translation editing panel
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. enum    {    GAD_PAGE=1,GAD_USE,GAD_DEFAULT,GAD_LOAD,GAD_SAVE,GAD_CANCEL,GAD_CLOSE,
  17.             GAD_DISCARD,GAD_SEND_CODE_AS,GAD_RECEIVE_CODE_AS,
  18.             GAD_CHAR=700
  19.         };
  20.  
  21. STATIC BOOL
  22. CodePanel(struct Window *Window,UBYTE CharCode,struct TranslationEntry **SendTable,struct TranslationEntry **ReceiveTable)
  23. {
  24.     LayoutHandle *Handle;
  25.     BOOL Result;
  26.  
  27.     Result = FALSE;
  28.  
  29.     if(Handle = LT_CreateHandleTags(Window->WScreen,
  30.         LAHN_LocaleHook,    &LocaleHook,
  31.     TAG_DONE))
  32.     {
  33.         struct Window *PanelWindow;
  34.         UBYTE SendBuffer[256],ReceiveBuffer[256];
  35.         UBYTE LocalBuffer[256];
  36.  
  37.         if(SendTable[CharCode])
  38.             TranslateBack(SendTable[CharCode]->String,SendTable[CharCode]->Len,SendBuffer,sizeof(SendBuffer));
  39.         else
  40.             SendBuffer[0] = 0;
  41.  
  42.         if(ReceiveTable[CharCode])
  43.             TranslateBack(ReceiveTable[CharCode]->String,ReceiveTable[CharCode]->Len,ReceiveBuffer,sizeof(ReceiveBuffer));
  44.         else
  45.             ReceiveBuffer[0] = 0;
  46.  
  47.         LT_New(Handle,
  48.             LA_Type,    VERTICAL_KIND,
  49.         TAG_DONE);
  50.         {
  51.             UBYTE OctalBuffer[6],HexBuffer[6],BinBuffer[10];
  52.             LONG Code,i;
  53.  
  54.             OctalBuffer[0] = '0';
  55.  
  56.             for(Code = CharCode, i = 0 ; i < 3 ; i++)
  57.             {
  58.                 OctalBuffer[2 - i + 1] = '0' + (Code & 7);
  59.  
  60.                 Code = Code >> 3;
  61.             }
  62.  
  63.             OctalBuffer[4] = 0;
  64.  
  65.             LimitedSPrintf(sizeof(HexBuffer),HexBuffer,"$%02lx",CharCode);
  66.  
  67.             BinBuffer[0] = '%';
  68.  
  69.             for(Code = CharCode, i = 0 ; i < 8 ; i++)
  70.             {
  71.                 BinBuffer[7 - i + 1] = '0' + (Code & 1);
  72.  
  73.                 Code = Code >> 1;
  74.             }
  75.  
  76.             BinBuffer[9] = 0;
  77.  
  78.             if(CharCodes[CharCode][0] == '1' && CharCodes[CharCode][1])
  79.                 LimitedSPrintf(sizeof(LocalBuffer),LocalBuffer,LocaleString(MSG_V36_1772),CharCodes[CharCode]);
  80.             else
  81.                 LimitedSPrintf(sizeof(LocalBuffer),LocalBuffer,LocaleString(MSG_V36_1773),CharCode,CharCodes[CharCode]);
  82.  
  83.             LimitedSPrintf(sizeof(LocalBuffer),LocalBuffer + strlen(LocalBuffer)," · %s · %s · %s",HexBuffer,OctalBuffer,BinBuffer);
  84.  
  85.             LT_New(Handle,
  86.                 LA_Type,        VERTICAL_KIND,
  87.                 LA_LabelText,    LocalBuffer,
  88.             TAG_DONE);
  89.             {
  90.                 LT_New(Handle,
  91.                     LA_Type,                STRING_KIND,
  92.                     LA_LabelID,                MSG_TRANSLATIONPANEL_SEND_CODE_AS_GAD,
  93.                     LA_STRPTR,                SendBuffer,
  94.                     LA_Chars,                30,
  95.                     LA_ID,                    GAD_SEND_CODE_AS,
  96.                     STRINGA_Justification,    GACT_STRINGCENTER,
  97.                     GTST_MaxChars,            sizeof(SendBuffer) - 1,
  98.                 TAG_DONE);
  99.  
  100.                 LT_New(Handle,
  101.                     LA_Type,                STRING_KIND,
  102.                     LA_LabelID,                MSG_TRANSLATIONPANEL_RECEIVE_CODE_AS_GAD,
  103.                     LA_STRPTR,                ReceiveBuffer,
  104.                     LA_ID,                    GAD_RECEIVE_CODE_AS,
  105.                     STRINGA_Justification,    GACT_STRINGCENTER,
  106.                     GTST_MaxChars,            sizeof(ReceiveBuffer) - 1,
  107.                 TAG_DONE);
  108.  
  109.                 LT_EndGroup(Handle);
  110.             }
  111.  
  112.             LT_New(Handle,
  113.                 LA_Type,VERTICAL_KIND,
  114.             TAG_DONE);
  115.             {
  116.                 LT_New(Handle,
  117.                     LA_Type,        XBAR_KIND,
  118.                     LAXB_FullSize,    TRUE,
  119.                 TAG_DONE);
  120.  
  121.                 LT_EndGroup(Handle);
  122.             }
  123.  
  124.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  125.                 LAGR_SameSize,    TRUE,
  126.                 LAGR_Spread,    TRUE,
  127.             TAG_DONE);
  128.             {
  129.                 LT_New(Handle,
  130.                     LA_Type,        BUTTON_KIND,
  131.                     LA_LabelID,        MSG_GLOBAL_USE_GAD,
  132.                     LA_ID,            GAD_USE,
  133.                     LABT_ReturnKey,    TRUE,
  134.                     LABT_ExtraFat,    TRUE,
  135.                 TAG_DONE);
  136.  
  137.                 LT_New(Handle,
  138.                     LA_Type,        BUTTON_KIND,
  139.                     LA_LabelID,        MSG_GLOBAL_DEFAULT_GAD,
  140.                     LA_ID,            GAD_DEFAULT,
  141.                     LA_NoKey,        TRUE,
  142.                     LABT_ExtraFat,    TRUE,
  143.                 TAG_DONE);
  144.  
  145.                 LT_New(Handle,
  146.                     LA_Type,        BUTTON_KIND,
  147.                     LA_LabelID,        MSG_GLOBAL_CANCEL_GAD,
  148.                     LA_ID,            GAD_CANCEL,
  149.                     LABT_EscKey,    TRUE,
  150.                 TAG_DONE);
  151.  
  152.                 LT_EndGroup(Handle);
  153.             }
  154.  
  155.             LT_EndGroup(Handle);
  156.         }
  157.  
  158.         if(PanelWindow = LT_Build(Handle,
  159.             LAWN_TitleID,        MSG_TRANSLATIONPANEL_CHARACTER_CODE_TRANSLATION_TXT,
  160.             LAWN_HelpHook,        &GuideHook,
  161.             LAWN_Parent,        Window,
  162.             WA_DepthGadget,        TRUE,
  163.             WA_DragBar,            TRUE,
  164.             WA_RMBTrap,            TRUE,
  165.             WA_Activate,        TRUE,
  166.             WA_SimpleRefresh,    TRUE,
  167.         TAG_DONE))
  168.         {
  169.             struct IntuiMessage    *Message;
  170.             struct Gadget *MsgGadget;
  171.             ULONG MsgClass;
  172.             BOOL Done;
  173.  
  174.             LT_ShowWindow(Handle,TRUE);
  175.  
  176.             GuideContext(CONTEXT_TRANSLATION);
  177.  
  178.             PushWindow(PanelWindow);
  179.  
  180.             Done = FALSE;
  181.  
  182.             do
  183.             {
  184.                 if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  185.                     break;
  186.  
  187.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  188.                 {
  189.                     MsgClass    = Message->Class;
  190.                     MsgGadget    = (struct Gadget *)Message->IAddress;
  191.  
  192.                     LT_ReplyIMsg(Message);
  193.  
  194.                     if(MsgClass == IDCMP_GADGETUP)
  195.                     {
  196.                         switch(MsgGadget->GadgetID)
  197.                         {
  198.                             case GAD_DEFAULT:
  199.  
  200.                                 LocalBuffer[0] = CharCode;
  201.  
  202.                                 TranslateBack(LocalBuffer,1,SendBuffer,sizeof(SendBuffer));
  203.                                 TranslateBack(LocalBuffer,1,ReceiveBuffer,sizeof(ReceiveBuffer));
  204.  
  205.                                 LT_SetAttributes(Handle,GAD_SEND_CODE_AS,
  206.                                     GTST_String,SendBuffer,
  207.                                 TAG_DONE);
  208.  
  209.                                 LT_SetAttributes(Handle,GAD_RECEIVE_CODE_AS,
  210.                                     GTST_String,ReceiveBuffer,
  211.                                 TAG_DONE);
  212.  
  213.                                 break;
  214.  
  215.                             case GAD_USE:
  216.  
  217.                                 LT_UpdateStrings(Handle);
  218.  
  219.                                 if(SendBuffer[0])
  220.                                 {
  221.                                     struct TranslationEntry *Entry = AllocTranslationEntry(SendBuffer);
  222.  
  223.                                     if(Entry)
  224.                                     {
  225.                                         if(SendTable[CharCode])
  226.                                             FreeTranslationEntry(SendTable[CharCode]);
  227.  
  228.                                         SendTable[CharCode] = Entry;
  229.  
  230.                                         Result = TRUE;
  231.                                     }
  232.                                 }
  233.                                 else
  234.                                 {
  235.                                     if(SendTable[CharCode])
  236.                                         FreeTranslationEntry(SendTable[CharCode]);
  237.  
  238.                                     SendTable[CharCode] = NULL;
  239.  
  240.                                     Result = TRUE;
  241.                                 }
  242.  
  243.                                 if(ReceiveBuffer[0])
  244.                                 {
  245.                                     struct TranslationEntry *Entry = AllocTranslationEntry(ReceiveBuffer);
  246.  
  247.                                     if(Entry)
  248.                                     {
  249.                                         if(ReceiveTable[CharCode])
  250.                                             FreeTranslationEntry(ReceiveTable[CharCode]);
  251.  
  252.                                         ReceiveTable[CharCode] = Entry;
  253.  
  254.                                         Result = TRUE;
  255.                                     }
  256.                                 }
  257.                                 else
  258.                                 {
  259.                                     if(ReceiveTable[CharCode])
  260.                                         FreeTranslationEntry(ReceiveTable[CharCode]);
  261.  
  262.                                     ReceiveTable[CharCode] = NULL;
  263.  
  264.                                     Result = TRUE;
  265.                                 }
  266.  
  267.                                 Done = TRUE;
  268.                                 break;
  269.  
  270.                             case GAD_CANCEL:
  271.  
  272.                                 Done = TRUE;
  273.                                 break;
  274.                         }
  275.                     }
  276.                 }
  277.             }
  278.             while(!Done);
  279.  
  280.             PopWindow();
  281.         }
  282.  
  283.         LT_DeleteHandle(Handle);
  284.     }
  285.  
  286.     return(Result);
  287. }
  288.  
  289. BOOL
  290. TranslationPanelConfig(struct Configuration *LocalConfig,struct TranslationEntry ***SendTablePtr,struct TranslationEntry ***ReceiveTablePtr,STRPTR LastTranslation,struct Window *Parent,BOOL *ChangePtr)
  291. {
  292.     struct TranslationEntry    **SendTable,**ReceiveTable;
  293.     BOOL MadeChanges,Created;
  294.     LayoutHandle *Handle;
  295.  
  296.     MadeChanges        = FALSE;
  297.     Created            = FALSE;
  298.  
  299.     SendTable        = *SendTablePtr;
  300.     ReceiveTable    = *ReceiveTablePtr;
  301.  
  302.     if(!SendTable)
  303.     {
  304.         if(!(SendTable = AllocTranslationTable()))
  305.         {
  306.             DisplayBeep(Window->WScreen);
  307.  
  308.             return(FALSE);
  309.         }
  310.  
  311.         if(!(ReceiveTable = AllocTranslationTable()))
  312.         {
  313.             DisplayBeep(Window->WScreen);
  314.  
  315.             FreeTranslationTable(SendTable);
  316.  
  317.             return(FALSE);
  318.         }
  319.  
  320.         if(!FillTranslationTable(SendTable))
  321.         {
  322.             DisplayBeep(Window->WScreen);
  323.  
  324.             FreeTranslationTable(SendTable);
  325.             FreeTranslationTable(ReceiveTable);
  326.  
  327.             return(FALSE);
  328.         }
  329.  
  330.         if(!FillTranslationTable(ReceiveTable))
  331.         {
  332.             DisplayBeep(Window->WScreen);
  333.  
  334.             FreeTranslationTable(SendTable);
  335.             FreeTranslationTable(ReceiveTable);
  336.  
  337.             return(FALSE);
  338.         }
  339.  
  340.         Created = TRUE;
  341.     }
  342.  
  343.     *SendTablePtr        = SendTable;
  344.     *ReceiveTablePtr    = ReceiveTable;
  345.  
  346.     if(Handle = LT_CreateHandleTags(Parent->WScreen,
  347.         LAHN_LocaleHook,    &LocaleHook,
  348.     TAG_DONE))
  349.     {
  350.         struct Window *PanelWindow;
  351.         LONG Width,Max,i;
  352.  
  353.         Max = 0;
  354.  
  355.         for(i = 0 ; i < 256 ; i++)
  356.         {
  357.             if((Width = LT_LabelChars(Handle,CharCodes[i])) > Max)
  358.                 Max = Width;
  359.         }
  360.  
  361.         LT_New(Handle,
  362.             LA_Type,VERTICAL_KIND,
  363.         TAG_DONE);
  364.         {
  365.             LT_New(Handle,
  366.                 LA_Type,VERTICAL_KIND,
  367.             TAG_DONE);
  368.             {
  369.                 STATIC STRPTR Halfs[] =
  370.                 {
  371.                     "NUL-DEL",
  372.                     "128-\"ÿ\"",
  373.                     NULL
  374.                 };
  375.  
  376.                 LT_New(Handle,
  377.                     LA_Type,        TAB_KIND,
  378.                     LA_LabelID,        MSG_TRANSLATIONPANEL_CHARACTER_PAGE_GAD,
  379.                     LA_ID,            GAD_PAGE,
  380.                     GTCY_Labels,    Halfs,
  381.                     LA_NoKey,        TRUE,
  382.                     LATB_FullWidth,    TRUE,
  383.                 TAG_DONE);
  384.  
  385.                 LT_EndGroup(Handle);
  386.             }
  387.  
  388.             LT_New(Handle,
  389.                 LA_Type,VERTICAL_KIND,
  390.             TAG_DONE);
  391.             {
  392.                 LONG j;
  393.  
  394.                 for(i = 0 ; i < 8 ; i++)
  395.                 {
  396.                     LT_New(Handle,
  397.                         LA_Type,        HORIZONTAL_KIND,
  398.                         LAGR_SameSize,    TRUE,
  399.                     TAG_DONE);
  400.                     {
  401.                         for(j = 0 ; j < 16 ; j++)
  402.                         {
  403.                             LT_New(Handle,
  404.                                 LA_Type,        BUTTON_KIND,
  405.                                 LA_LabelText,    CharCodes[i * 16 + j],
  406.                                 LA_ID,            GAD_CHAR + i * 16 + j,
  407.                                 LA_Chars,        Max,
  408.                                 LA_NoKey,        TRUE,
  409.                             TAG_DONE);
  410.                         }
  411.  
  412.                         LT_EndGroup(Handle);
  413.                     }
  414.                 }
  415.  
  416.                 LT_EndGroup(Handle);
  417.             }
  418.  
  419.             LT_New(Handle,
  420.                 LA_Type,VERTICAL_KIND,
  421.             TAG_DONE);
  422.             {
  423.                 LT_New(Handle,
  424.                     LA_Type,        XBAR_KIND,
  425.                     LAXB_FullSize,    TRUE,
  426.                 TAG_DONE);
  427.  
  428.                 LT_EndGroup(Handle);
  429.             }
  430.  
  431.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  432.                 LAGR_Spread,TRUE,
  433.             TAG_DONE);
  434.             {
  435.                 LT_New(Handle,
  436.                     LA_Type,        BUTTON_KIND,
  437.                     LA_LabelID,        MSG_GLOBAL_USE_GAD,
  438.                     LA_ID,            GAD_USE,
  439.                     LA_NoKey,        TRUE,
  440.                     LABT_ExtraFat,    TRUE,
  441.                 TAG_DONE);
  442.  
  443.                 LT_New(Handle,
  444.                     LA_Type,        BUTTON_KIND,
  445.                     LA_LabelID,        MSG_GLOBAL_DEFAULT_GAD,
  446.                     LA_ID,            GAD_DEFAULT,
  447.                     LA_NoKey,        TRUE,
  448.                     LABT_ExtraFat,    TRUE,
  449.                 TAG_DONE);
  450.  
  451.                 LT_New(Handle,
  452.                     LA_Type,        BUTTON_KIND,
  453.                     LA_LabelID,        MSG_GLOBAL_LOAD_GAD,
  454.                     LA_ID,            GAD_LOAD,
  455.                     LA_NoKey,        TRUE,
  456.                     LABT_ExtraFat,    TRUE,
  457.                 TAG_DONE);
  458.  
  459.                 LT_New(Handle,
  460.                     LA_Type,        BUTTON_KIND,
  461.                     LA_LabelID,        MSG_GLOBAL_SAVE_GAD,
  462.                     LA_ID,            GAD_SAVE,
  463.                     LA_NoKey,        TRUE,
  464.                     LABT_ExtraFat,    TRUE,
  465.                 TAG_DONE);
  466.  
  467.                 LT_New(Handle,
  468.                     LA_Type,        BUTTON_KIND,
  469.                     LA_LabelID,        MSG_DISCARD_GAD,
  470.                     LA_ID,            GAD_DISCARD,
  471.                     LA_NoKey,        TRUE,
  472.                     LABT_ExtraFat,    TRUE,
  473.                 TAG_DONE);
  474.  
  475.                 LT_New(Handle,
  476.                     LA_Type,        BUTTON_KIND,
  477.                     LA_LabelID,        MSG_GLOBAL_CLOSE_TXT,
  478.                     LA_ID,            GAD_CANCEL,
  479.                     LA_NoKey,        TRUE,
  480.                     LABT_ExtraFat,    TRUE,
  481.                 TAG_DONE);
  482.  
  483.                 LT_EndGroup(Handle);
  484.             }
  485.  
  486.             LT_EndGroup(Handle);
  487.         }
  488.  
  489.         if(PanelWindow = LT_Build(Handle,
  490.             LAWN_TitleID,        MSG_TRANSLATIONPANEL_CHARACTER_TABLE_TXT,
  491.             LAWN_HelpHook,        &GuideHook,
  492.             LAWN_Parent,        Parent,
  493.             WA_DepthGadget,        TRUE,
  494.             WA_DragBar,            TRUE,
  495.             WA_RMBTrap,            TRUE,
  496.             WA_Activate,        TRUE,
  497.             WA_SimpleRefresh,    TRUE,
  498.         TAG_DONE))
  499.         {
  500.             UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  501.             struct FileRequester *FileRequest;
  502.             struct IntuiMessage *Message;
  503.             ULONG MsgClass,MsgQualifier;
  504.             struct Gadget *MsgGadget;
  505.             UWORD MsgCode;
  506.             LONG CharBase;
  507.             LONG KeyCode;
  508.             BOOL Done;
  509.  
  510.             CharBase = 0;
  511.  
  512.             PushWindow(PanelWindow);
  513.  
  514.             LT_ShowWindow(Handle,TRUE);
  515.  
  516.             Done = FALSE;
  517.  
  518.             do
  519.             {
  520.                 if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  521.                     break;
  522.  
  523.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow->UserPort))
  524.                 {
  525.                     MsgClass        = Message->Class;
  526.                     MsgQualifier    = Message->Qualifier;
  527.                     MsgCode            = Message->Code;
  528.                     MsgGadget        = (struct Gadget *)Message->IAddress;
  529.  
  530.                     if(MsgClass == IDCMP_RAWKEY)
  531.                         KeyCode = LT_GetCode(MsgQualifier,MsgClass,MsgCode,MsgGadget);
  532.                     else
  533.                         KeyCode = -1;
  534.  
  535.                     GT_ReplyIMsg(Message);
  536.  
  537.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  538.  
  539.                     if(KeyCode != -1)
  540.                     {
  541.                         if(KeyCode >= CharBase && KeyCode < CharBase + 128)
  542.                             LT_PressButton(Handle,GAD_CHAR + KeyCode - CharBase);
  543.  
  544.                         LT_LockWindow(PanelWindow);
  545.  
  546.                         MadeChanges |= CodePanel(PanelWindow,KeyCode,SendTable,ReceiveTable);
  547.  
  548.                         if(ChangePtr)
  549.                             *ChangePtr |= MadeChanges;
  550.  
  551.                         LT_UnlockWindow(PanelWindow);
  552.  
  553.                         LT_ShowWindow(Handle,TRUE);
  554.                     }
  555.  
  556.                     if(MsgClass == IDCMP_GADGETUP)
  557.                     {
  558.                         switch(MsgGadget->GadgetID)
  559.                         {
  560.                             case GAD_PAGE:
  561.  
  562.                                 LT_LockWindow(PanelWindow);
  563.  
  564.                                 if(MsgCode)
  565.                                 {
  566.                                     for(i = 0 ; i < 128 ; i++)
  567.                                         LT_SetAttributes(Handle,GAD_CHAR + i,LA_LabelText,CharCodes[128 + i],TAG_DONE);
  568.  
  569.                                     CharBase = 128;
  570.                                 }
  571.                                 else
  572.                                 {
  573.                                     for(i = 0 ; i < 128 ; i++)
  574.                                         LT_SetAttributes(Handle,GAD_CHAR + i,LA_LabelText,CharCodes[0 + i],TAG_DONE);
  575.  
  576.                                     CharBase = 0;
  577.                                 }
  578.  
  579.                                 if(!LT_Rebuild(Handle,NULL,0,0,FALSE))
  580.                                 {
  581.                                     LT_DeleteHandle(Handle);
  582.  
  583.                                     Handle = NULL;
  584.  
  585.                                     Done = TRUE;
  586.                                 }
  587.                                 else
  588.                                     LT_UnlockWindow(PanelWindow);
  589.  
  590.                                 break;
  591.  
  592.                             case GAD_DISCARD:
  593.  
  594.                                 MadeChanges = Done = TRUE;
  595.                                 LastTranslation[0] = 0;
  596.  
  597.                                 if(LocalConfig)
  598.                                     strcpy(LocalConfig->TranslationFileName,LastTranslation);
  599.  
  600.                             case GAD_DEFAULT:
  601.  
  602.                                 if(SendTable)
  603.                                 {
  604.                                     struct TranslationEntry **Table;
  605.  
  606.                                     if(Table = AllocTranslationTable())
  607.                                     {
  608.                                         if(FillTranslationTable(Table))
  609.                                         {
  610.                                             FreeTranslationTable(SendTable);
  611.  
  612.                                             SendTable = Table;
  613.                                         }
  614.                                     }
  615.                                 }
  616.  
  617.                                 if(ReceiveTable)
  618.                                 {
  619.                                     struct TranslationEntry **Table;
  620.  
  621.                                     if(Table = AllocTranslationTable())
  622.                                     {
  623.                                         if(FillTranslationTable(Table))
  624.                                         {
  625.                                             FreeTranslationTable(ReceiveTable);
  626.  
  627.                                             ReceiveTable = Table;
  628.                                         }
  629.                                     }
  630.                                 }
  631.  
  632.                                 break;
  633.  
  634.                             case GAD_CLOSE:
  635.                             case GAD_USE:
  636.  
  637.                                 Done = TRUE;
  638.                                 break;
  639.  
  640.                             case GAD_CANCEL:
  641.  
  642.                                 Done = TRUE;
  643.                                 break;
  644.  
  645.                             case GAD_LOAD:
  646.  
  647.                                 LT_LockWindow(PanelWindow);
  648.  
  649.                                 strcpy(DummyBuffer,LastTranslation);
  650.  
  651.                                 if(FileRequest = OpenSingleFile(PanelWindow,LocaleString(MSG_TRANSLATIONPANEL_LOAD_TRANSLATION_TABLES_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  652.                                 {
  653.                                     struct TranslationEntry **Send,**Receive;
  654.                                     BOOL Success;
  655.  
  656.                                     Success = FALSE;
  657.                                     Receive = NULL;
  658.  
  659.                                     FreeAslRequest(FileRequest);
  660.  
  661.                                     if(Send = AllocTranslationTable())
  662.                                     {
  663.                                         if(Receive = AllocTranslationTable())
  664.                                             Success = LoadTranslationTables(DummyBuffer,Send,Receive);
  665.                                     }
  666.  
  667.                                     if(!Success)
  668.                                     {
  669.                                         ShowError(PanelWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  670.  
  671.                                         if(Send)
  672.                                             FreeTranslationTable(Send);
  673.  
  674.                                         if(Receive)
  675.                                             FreeTranslationTable(Receive);
  676.                                     }
  677.                                     else
  678.                                     {
  679.                                         if(LocalConfig)
  680.                                             strcpy(LocalConfig->TranslationFileName,DummyBuffer);
  681.  
  682.                                         strcpy(LastTranslation,DummyBuffer);
  683.  
  684.                                         MadeChanges    = TRUE;
  685.                                         Created        = FALSE;
  686.  
  687.                                         FreeTranslationTable(SendTable);
  688.                                         FreeTranslationTable(ReceiveTable);
  689.  
  690.                                         SendTable        = Send;
  691.                                         ReceiveTable    = Receive;
  692.  
  693.                                         if(ChangePtr)
  694.                                             *ChangePtr = FALSE;
  695.                                     }
  696.                                 }
  697.  
  698.                                 LT_UnlockWindow(PanelWindow);
  699.                                 break;
  700.  
  701.                             case GAD_SAVE:
  702.  
  703.                                 LT_LockWindow(PanelWindow);
  704.  
  705.                                 strcpy(DummyBuffer,LastTranslation);
  706.  
  707.                                 if(FileRequest = SaveFile(PanelWindow,LocaleString(MSG_TRANSLATIONPANEL_SAVE_TRANSLATION_TABLES_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  708.                                 {
  709.                                     FreeAslRequest(FileRequest);
  710.  
  711.                                     if(!SaveTranslationTables(DummyBuffer,SendTable,ReceiveTable))
  712.                                         ShowError(PanelWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  713.                                     else
  714.                                     {
  715.                                         strcpy(LastTranslation,DummyBuffer);
  716.  
  717.                                         if(LocalConfig)
  718.                                             strcpy(LocalConfig->TranslationFileName,LastTranslation);
  719.  
  720.                                         Created = FALSE;
  721.  
  722.                                         if(ChangePtr)
  723.                                             *ChangePtr = FALSE;
  724.                                     }
  725.                                 }
  726.  
  727.                                 LT_UnlockWindow(PanelWindow);
  728.                                 break;
  729.  
  730.                             default:
  731.  
  732.                                 if(MsgGadget->GadgetID >= GAD_CHAR && MsgGadget->GadgetID < GAD_CHAR + 128)
  733.                                 {
  734.                                     LT_LockWindow(PanelWindow);
  735.  
  736.                                     MadeChanges |= CodePanel(PanelWindow,CharBase + MsgGadget->GadgetID - GAD_CHAR,SendTable,ReceiveTable);
  737.  
  738.                                     if(ChangePtr)
  739.                                         *ChangePtr |= MadeChanges;
  740.  
  741.                                     LT_UnlockWindow(PanelWindow);
  742.  
  743.                                     LT_ShowWindow(Handle,TRUE);
  744.                                 }
  745.  
  746.                                 break;
  747.                         }
  748.                     }
  749.                 }
  750.             }
  751.             while(!Done);
  752.  
  753.             PopWindow();
  754.         }
  755.  
  756.         LT_DeleteHandle(Handle);
  757.     }
  758.  
  759.     if((!MadeChanges && Created) || (IsStandardTable(SendTable) && IsStandardTable(ReceiveTable)))
  760.     {
  761.         FreeTranslationTable(SendTable);
  762.         SendTable = NULL;
  763.  
  764.         FreeTranslationTable(ReceiveTable);
  765.         ReceiveTable = NULL;
  766.     }
  767.  
  768.     *SendTablePtr        = SendTable;
  769.     *ReceiveTablePtr    = ReceiveTable;
  770.  
  771.     return(MadeChanges);
  772. }
  773.